/**
 * HTTP 请求工具
 * @description 基于 luch-request 封装的 HTTP 请求工具，提供统一的请求配置、拦截器和错误处理
 * @module utils/request
 * @see https://www.quanzhan.co/luch-request/guide/3.x/
 * @example
 * // 基础用法
 * import { get, post } from '@/utils/request'
 *
 * // GET 请求
 * const data = await get('/api/users')
 *
 * // POST 请求
 * const result = await post('/api/users', { name: 'test' })
 *
 * @example
 * // 自定义配置
 * get('/api/users', null, {
 *   custom: {
 *     loading: true,      // 显示加载提示
 *     auth: false,        // 不需要认证
 *   }
 * })
 */

import Request from 'luch-request'
import {
  API_BASE_URL,
  AUTH_TOKEN_KEY,
  REQUEST_LOADING,
  REQUEST_LOADING_MASK,
  REQUEST_LOADING_TEXT,
  REQUEST_NETWORK_ERROR_TEXT,
  REQUEST_TIMEOUT,
} from '@/config'
import { ResponseCode } from '@/enum'
import store from '@/store'
import { getToken, setToken, removeToken } from '@/utils/auth'
/**
 * custom 配置项说明：
 * - auth: 是否需要认证，默认为 true
 * - loading: 是否显示加载提示，默认为 REQUEST_LOADING，在 src/config/request.js 中配置
 * - returnResponseHeader: 是否返回响应头，默认为 false
 */

// 创建请求实例
const http = new Request({
  baseURL: API_BASE_URL,
  timeout: REQUEST_TIMEOUT,
  header: {
    'Content-Type': 'application/json',
    'source-client': 'miniapp',
  },
  custom: {
    loading: REQUEST_LOADING,
  },
})

// 请求拦截器
http.interceptors.request.use(
  /**
   * 请求拦截器
   * @param {Object} config 请求配置
   * @returns {Object} 处理后的请求配置
   */
  config => {
    const { custom = {}, header = {} } = config
    const { auth = true, loading } = custom

    // 处理认证
    const token = getToken()
    console.log(store, 'token');

    if (token) header[AUTH_TOKEN_KEY] = `Bearer ${token}`
    config.header = header

    // 处理 loading
    loading && uni.showLoading({ title: REQUEST_LOADING_TEXT, mask: REQUEST_LOADING_MASK })
    return config
  },
  error => Promise.reject(error),
)

/**
 * 是否正在跳转登录页（防止重复跳转）
 */
let isRedirecting = false

/**
 * 跳转到登录页面并清除用户信息
 */
const redirectToLogin = () => {
  // 防止重复跳转
  if (isRedirecting) return
  isRedirecting = true
  
  // 清除用户信息和 token
  removeToken()
  try {
    store.commit('user/CLEAR_USER_INFO')
    store.commit('token/CLEAR_TOKEN')
  } catch (e) {
    console.error('清除用户信息失败:', e)
  }
  
  // 显示提示
  uni.showToast({
    icon: 'none',
    title: '登录已失效，请重新登录',
    duration: 2000,
  })
  
  // 跳转到登录页
  setTimeout(() => {
    uni.reLaunch({ 
      url: '/subPages/auth/login',
      complete: () => {
        // 重置跳转状态
        setTimeout(() => {
          isRedirecting = false
        }, 1000)
      }
    })
  }, 500)
}

// 响应拦截器
http.interceptors.response.use(
  response => {
    const { statusCode, data, config } = response
    const { custom = {} } = config
    const { loading } = custom
    const { code } = data
    // 处理 loading
    loading && uni.hideLoading()
    
    // 处理成功响应 (2xx 状态码)
    if (code == ResponseCode.SUCCESS) return response
    // 处理 401 未授权 - 跳转到登录页
	console.log(code,212121);
    if (code === 401 || code === 403) {
      console.warn('未授权访问，需要重新登录')
      redirectToLogin()
      return Promise.reject({ message: '未授权，请重新登录', statusCode: 401 })
    }
  
    // 其他错误状态码 - 不跳转，只返回错误
    console.error('请求错误:', statusCode, data)
    const errorMessage = data?.message || data?.msg || `请求失败(${statusCode})`
    return Promise.reject({ message: errorMessage, statusCode, data })
  },
  error => {
    console.error('请求错误拦截:', error)
    
    // 安全获取配置信息
    const config = error.config || {}
    const custom = config.custom || {}
    const loading = custom.loading
    
    // 隐藏 loading
    if (loading) {
      uni.hideLoading()
    }
    
    // 获取响应数据
    const response = error.response
    const data = response?.data || error.data
    const statusCode = response?.statusCode || error.statusCode
    
    // 情况1: 有响应数据（服务器返回了错误）
    if (data) {
      const code = data.code
      const message = data.message || data.msg || data.error
      
      // 检查是否是 401 未授权
      if (code === 401 || code === 403 || code === 10004) {
        console.warn('未授权访问，需要重新登录')
        redirectToLogin()
        return Promise.reject({ 
          message: '未授权，请重新登录', 
          statusCode: 401,
          code 
        })
      }
      
      // 其他服务器错误
      const errorMessage = message || `请求失败(${statusCode || code})`
      console.error('服务器错误:', { code, statusCode, message: errorMessage })
      
      // 显示错误提示
      uni.showToast({
        icon: 'none',
        title: errorMessage,
        duration: 2000,
      })
      
      return Promise.reject({ 
        message: errorMessage, 
        statusCode,
        code,
        data 
      })
    }
    
    // 情况2: 没有响应数据（网络错误、超时等）
    const errorMessage = error.errMsg || error.message || REQUEST_NETWORK_ERROR_TEXT
    console.error('网络请求失败:', errorMessage)
    
    // 显示错误提示
    uni.showToast({
      icon: 'none',
      title: errorMessage,
      duration: 2000,
    })
    
    return Promise.reject({ 
      message: errorMessage, 
      error,
      isNetworkError: true 
    })
  },
)

/**
 * 基础请求方法
 */
export const request = async config => (await http.request(config)).data

// 导出常用的请求方法
export const get = (url, config) => request({ ...config, url, method: 'GET' })

export const post = (url, data, config) => request({ ...config, url, method: 'POST', data })

export const put = (url, data, config) => request({ ...config, url, method: 'PUT', data })

export const del = (url, config) => request({ ...config, url, method: 'DELETE' })

export default http
